Membrane stretch by Patryk26g · Pull Request #7084 · Revolutionary-Games/Thrive

Patryk26g · 2026-06-28T18:02:32Z

Brief Description of What This PR Does

Extends membrane in multicellular colonies to other cell neighbours.

Membrane is generated in 2 passes - first normally like for single cell expect without applying membrane waviness. Then in the second pass, which is currently performed on a single thread, gets cells neighbours.,calculates the position of middle point between these cell, creates tangent lines to the cell coming from that point and casts vertices onto these lines checking if the are not accidentally inside other neighbours' membrane. After that a smoothing is applied.

Note: membrane stretching in a colony is sequential for each cell, not asynchronous. It's because it needs other cells' membranes (both original and stretched) to avoid overlaps. Also during calculations both current and neighbours membranes are modified to avoid cases where one cell's vertices are modified and second's not because of overlaps. The code makes sure that either both stretch or none do.

Unfortunately there are list allocations for rotated and shifted neighbours vertices. Maybe I should use array pool there?

Related Issues

Progress Checklist

Note: before starting this checklist the PR should be marked as non-draft.

PR author has checked that this PR works as intended and doesn't
break existing features:
https://wiki.revolutionarygamesstudio.com/wiki/Testing_Checklist
(this is important as to not waste the time of Thrive team
members reviewing this PR). This includes gameplay testing by the PR author.
Initial code review passed (this and further items should not be checked by the PR author)
Functionality is confirmed working by another person (see above checklist link)
Final code review is passed and code conforms to the
styleguide.

Before merging all CI jobs should finish on this PR without errors, if
there are automatically detected style issues they should be fixed by
the PR author. Merging must follow our
styleguide.

Smoothing

revolutionary-bot · 2026-06-28T18:02:35Z

The lead programmer for Thrive is currently on vacation until 2026-07-13. Until then other programmers will try to make pull request reviews, but please be patient if your PR is not getting reviewed.

PRs may be merged after multiple programmers have approved the changes (especially making sure to ensure style guide conformance and gameplay testing are good). If there are no active experienced programmers who can perform merges, PRs may need to wait until the lead programmer is back to be merged.

…with other neighbours

hhyyrylainen · 2026-07-15T11:58:51Z

Is this still experimental or, should this be marked as a draft or is this ready for review?

hhyyrylainen · 2026-07-15T12:09:17Z

 {
    public Vector2[] HexPositions { get; }
    public int HexPositionCount { get; }
+    public Vector2[]? MulticellularPositions { get; }


Adding all of this extra data makes this a ton heavier, enough so that I fear for the efficiency of the overall design being able to handle things...

What exactly do you mean by "being able to handle things"? I unfortunatelly need all of this data to make good membrane stretch generation. What would you propose here instead?

The way I made the hashing and finding stuff is that I bedgrudginly accepted that the game has to hash the full list of positions, and that works fine now. But this PR increases the amount of hashing effort 5x, and makes membranes unique based on colony position, meaning that the overall caching system for membranes might not even make sense. So by adding a lot of heavy weight to the membrane caching system might hinder it so much that the entire concept needs to be rethought.

I suggested a few things to try to make it lighter (by using a single list, and only verifying some properties), but there might be a fundamental limit that causes problems with doing so much new stuff in the membrane caching and generation.

Patryk26g · 2026-07-15T12:13:00Z

Is this still experimental or, should this be marked as a draft or is this ready for review?

its ready for review

hhyyrylainen · 2026-07-16T12:16:04Z

+                continue;
+
+            var cell = multicellular.Species.ModifiableGameplayCells[i];
+            var cellPosistion = Hex.AxialToCartesian(cell.Position);


Suggested change

var cellPosistion = Hex.AxialToCartesian(cell.Position);

var cellPosition = Hex.AxialToCartesian(cell.Position);

Typo

hhyyrylainen · 2026-07-16T12:17:10Z

+        var positionsArray = cellsPositions.ToArray();
+        var rotationsArray = cellsOrientations.ToArray();


For memory efficiency, these should absolutely be avoided.

If temporary memory is needed I think these should use array buffer renting.

Or having read the generation request data, I think we should have just a single array with structs in it and those structs then would hold all data related to the other cells rather than spreading it across like 5 or so arrays as they are currently.

I guess that also applies to the dictionaries with lists as values, right?

I dont quite understand what you mean by array with structs in it - why structs would be better in this case then classes? they would constantly be copied across all the method calls, wouldn't they?

Anyway, I will try to improve it, either using the arrayPool or somehow implementing the struct concept

I guess that also applies to the dictionaries with lists as values, right?

Yes.

I dont quite understand what you mean by array with structs in it - why structs would be better in this case then classes? they would constantly be copied across all the method calls, wouldn't they?

In C# structs are value types, which means that ArrayStruct[] and List<ArrayStruct> both allocate only one continuous segment of memory. Whereas a list of class objects first allocates the list memory and then each class separately this causes memory fragmentation and major slowdown as the CPU prefetch doesn't work. So a list of classes is a memory performance nightmare in comparison to an array. Even better would be being able to rent arrays from the global array buffer and only needing to not return the array when actually generating a new membrane, this would take most of the load off from using a cached copy of data.

Anyway, I will try to improve it, either using the arrayPool or somehow implementing the struct concept

Yes, I think this would be a very key optimization.

I thought about using stackalloc originally but I couldn't figure out a way to use it because when you fill it and hash it, and find out that the membrane is not cached, then you need to make a second array you can actually give to the membrane generation object. So if our cache hit rate is low the extra copy from the stackalloc array to the array that can be given to the membrane object to hold, will be a major performance drain (and stackalloc wouldn't help), but I haven't extensively tested so I'm not actually sure if this problem is real.

hhyyrylainen · 2026-07-16T12:18:37Z


        var sourcePoints = dataSource.HexPositions;

+        if (dataSource.MulticellularPositions != null || multicellularPositions != null)


This looks quite bad in terms of new performance drain, so I would only keep the most important comparison and put all else behind a #if DEBUG condition check to still help catch bugs but not eat up runtime performance for players.

makes sense

hhyyrylainen · 2026-07-28T06:53:09Z

+                    continue;
+
+                var cell = multicellular.Species.ModifiableGameplayCells[i];
+                var cellPosistion = Hex.AxialToCartesian(cell.Position);


Suggested change

var cellPosistion = Hex.AxialToCartesian(cell.Position);

var cellPosition = Hex.AxialToCartesian(cell.Position);

hhyyrylainen · 2026-07-28T06:56:18Z

-
-            // TODO: already generate the 3D points here for use on the main thread for faster membrane creation?
+            // Use coordinator to handle both single-cell and multicellular two-pass generation.
+            var writtenHashes = MembraneGenerationCoordinator.HandleGenerationRequest(ref generationParameters);


This returns a new list? I think it would be better if HandleGenerationRequest would be given a persistent list stored in a field in this class.

hhyyrylainen · 2026-07-28T06:58:47Z

+    public int? CellOrientation { get; }
+    public long? ColonyKey { get; }


These two are boxed, so I think these should use a bool flag and a direct primitive type.

Also just noticed that CellPositionInMulticellular is also boxed.

Also this class still has a ton of lists, I'd prefer a single struct that combined

public struct MembraneGenerationCellData{ public Vector2 Position; public int CellOrientation; }

And then having one list with multicellular data using that struct.

hhyyrylainen · 2026-07-28T06:59:35Z

 {
+    public MembraneGenerationParameters(Vector2[] hexPositions, int hexPositionCount, MembraneType type,
+        Vector2[] multicellularPositions, Vector2 thisCellPosition, int[]? multicellularOrientations,
+        int? thisCellOrientation, long? colonyKey = null, bool isPreMulticellularStretch = false)


Nullable primitives also cause boxing here, so should be avoided. Maybe with constructor overloads where the optional ones are just missing?

hhyyrylainen · 2026-07-28T07:00:54Z

+                hash = (hash * prime1) ^ BitConverter.SingleToInt32Bits(dataSource.HexPositions[i].X);
+                hash = (hash * prime1) ^ BitConverter.SingleToInt32Bits(dataSource.HexPositions[i].Y);


It might be more efficient to read dataSource.HexPositions[i] into a local variable rather than doing 2 array lookups.

hhyyrylainen · 2026-07-28T07:01:28Z

    public static bool MembraneDataFieldsEqual(this IMembraneDataSource dataSource, Vector2[] otherPoints,
-        int otherPointCount, MembraneType otherType)
+        int otherPointCount, MembraneType otherType, Vector2? cellPositionInMulticellular = null,
+        int? cellOrientationInMulticellular = null, long? otherColonyKey = null)


Boxing happening here as well.

hhyyrylainen · 2026-07-28T07:02:41Z

+            }
+        }
+
+        if (dataSource.ColonyKey != null || otherColonyKey != null)


Looking at things here, I would make it so that in release mode only the colony key is checked and the above orientation and position checks are inside a #if DEBUG preprocessor directive.

hhyyrylainen · 2026-07-28T07:03:11Z

+    /// <summary>
+    ///   Handles membrane generation requests. For single-cell requests the list contains one hash.
+    /// </summary>
+    public static List<long> HandleGenerationRequest(ref MembraneGenerationParameters generationParameters)


Suggested change

public static List<long> HandleGenerationRequest(ref MembraneGenerationParameters generationParameters)

public static void HandleGenerationRequest(ref MembraneGenerationParameters generationParameters, List<long> result)

hhyyrylainen · 2026-07-28T07:04:01Z

+        var multicellularPositions = generationParameters.MulticellularPositions!;
+        var multicellularOrientations = generationParameters.MulticellularOrientations;
+        var cellPosition = generationParameters.CellPositionInMulticellular!.Value;
+        var cellOrientation = generationParameters.CellOrientation;


These variables should be after looking in the cache as it looks these are not used in that case so that would be more efficient.

hhyyrylainen · 2026-07-28T07:05:36Z

+        }
+        else
+        {
+            colonyKey = ComputeColonyKey(multicellularPositions, multicellularOrientations);


Shouldn't the colony key be always present? Shouldn't this print a performance warning if it is missing?

hhyyrylainen · 2026-07-28T07:07:46Z

+
+        tracker.NeighboursData[CellKey(cellPosition)] = singleCellData;
+
+        // Colony not yet complete — return empty


It's probably rare enough that colony trackers never finish, right? So them leaking is at most a very slow resource leak... I was thinking that maybe to fix that the membrane generation system could like every minute clear out any trackers that are inactive for 15+ seconds, but that's a relatively complex thing to add.

hhyyrylainen · 2026-07-28T07:10:11Z

-        IReadOnlyList<Vector2> verticesToCopy)
+        IReadOnlyList<Vector2> verticesToCopy, Vector2 averageVertex, Vector2[]? multicellularPositions = null,
+        Vector2? cellPositionInMulticellular = null, int[]? multicellularOrientations = null,
+        int? cellOrientation = null, bool isPreMulticellularStretch = false, long? colonyKey = null)


Boxing happening here.

hhyyrylainen · 2026-07-28T07:10:40Z

+    public int? CellOrientation { get; }
+
+    /// <summary>
+    ///   Precomputed colony key that encodes neighbour positions and rotations for caching/equality.
+    /// </summary>
+    public long? ColonyKey { get; }
+


These two cause boxing.

hhyyrylainen · 2026-07-28T07:11:12Z

+    /// <summary>
+    ///   Positions of other cells in multicellular organism
+    /// </summary>
+    public Vector2[]? MulticellularPositions { get; }


This and the rotation could be combined into a single list with a struct like I commented already.

hhyyrylainen · 2026-07-28T07:11:17Z

+    /// <summary>
+    ///   Position of current cell in multicellular body plan
+    /// </summary>
+    public Vector2? CellPositionInMulticellular { get; }


Boxing here.

hhyyrylainen · 2026-07-28T07:12:40Z

        float distanceSquared = 0;

-        foreach (var vertex in Vertices2D)
+        for (int i = 0; i < VertexCount; ++i)


Why was this changed to a loop like this? As this is a plain array, foreach doesn't allocate memory, but VertexCount as a property causes an extra method call each iteration of the loop. So if you really want to change this, read the count into a local variable before the loop.

hhyyrylainen · 2026-07-28T07:13:53Z

    /// </returns>
-    public MembranePointData GenerateShape(Vector2[] hexPositions, int hexCount, MembraneType membraneType)
+    public MembranePointData GenerateMicrobeShape(Vector2[] hexPositions, int hexCount, MembraneType membraneType,
+        bool isMulticellular = false, long? colonyKey = null)


colonyKey is being boxed here.

hhyyrylainen · 2026-07-28T07:14:35Z


-        // Get new membrane points for vertices2D
-        GenerateMembranePoints(hexPositions, hexCount, membraneType);
+        var averagePoint = GetAverageVertex();


Is the average point always needed? If not I think it could be made so that it is calculated upon the first try to use it?

hhyyrylainen · 2026-07-28T07:23:57Z

+        for (int i = 0; i < vertexCount; ++i)
        {
-            center += new Vector3(point.X, 0.0f, point.Y);
+            center += new Vector3(vertices2D[i].X, 0.0f, vertices2D[i].Y);


Also potentially less efficient loop here as well especially as the array is read twice inside the loop rather than once.

hhyyrylainen · 2026-07-28T07:25:15Z

+            return false;
+
+        // Determine winding from the first edge so we know which sign = "inside"
+        float firstCross = Cross(vertices[0], vertices[1], point);


I'd add a #if DEBUG check here to ensure that the vertices list is at least 2 items as otherwise this line throws an index out of range exception.

hhyyrylainen · 2026-07-28T07:26:46Z

+        var ba = a - b;
+        var bc = c - b;
+
+        var angle = ba.AngleTo(bc) * MathUtils.DEGREES_TO_RADIANS;


Doesn't this use the wrong constant? Shouldn't this use RADIANS_TO_DEGREES? Because right now it looks like angle is made into radians and then you a line later use 180 to compare which looks to be in degrees, so there's a mismatch here.

hhyyrylainen · 2026-07-28T07:27:51Z

+                continue;
+
+            // Perpendicular distance from vertex to the ray
+            float distanceToRay = (directionToVertex - direction * projection).Length();


Does this have to use Length? It is much, much less efficient than length squared and that still allows relative comparisons.

hhyyrylainen · 2026-07-28T07:29:20Z

+    }
+
+    /// <summary>
+    ///   Define from which index of verices2D to which index the points should be moved


Suggested change

/// Define from which index of verices2D to which index the points should be moved

/// Define from which index of vertices2D to which index the points should be moved

hhyyrylainen · 2026-07-28T07:29:28Z

+    /// <summary>
+    ///   Define from which index of verices2D to which index the points should be moved
+    /// </summary>
+    /// <param name="vertices"> The list of vertices </param>


Suggested change

/// <param name="vertices"> The list of vertices </param>

/// <param name="vertices">The list of vertices</param>

hhyyrylainen · 2026-07-28T07:29:51Z

+    /// <param name="tangentPointIndexA"> First tangent line's point on the membrane </param>
+    /// <param name="tangentPointIndexB"> Second tangent line's point on the membrane </param>
+    /// <param name="reachVertexIndex"> A point on the membrane between the tangent points </param>
+    /// <param name="indexStart"> The starting index for the iteration </param>
+    /// <param name="indexEnd"> The ending index for the iteration </param>


Suggested change

/// <param name="tangentPointIndexA"> First tangent line's point on the membrane </param>

/// <param name="tangentPointIndexB"> Second tangent line's point on the membrane </param>

/// <param name="reachVertexIndex"> A point on the membrane between the tangent points </param>

/// <param name="indexStart"> The starting index for the iteration </param>

/// <param name="indexEnd"> The ending index for the iteration </param>

/// <param name="tangentPointIndexA">First tangent line's point on the membrane</param>

/// <param name="tangentPointIndexB">Second tangent line's point on the membrane</param>

/// <param name="reachVertexIndex">A point on the membrane between the tangent points</param>

/// <param name="indexStart">The starting index for the iteration</param>

/// <param name="indexEnd">The ending index for the iteration</param>

hhyyrylainen · 2026-07-28T07:30:32Z

+        var averageVertex = Vector2.Zero;
+        foreach (var vertex in vertices2D)
+            averageVertex += vertex;
+        averageVertex /= vertices2D.Count;


I think that for safety this should throw if vertices2D is empty.

hhyyrylainen · 2026-07-28T07:40:21Z

+                var vertex = editableNeighbourVertices[i];
+                vertex -= storedLocalOffset;
+                vertex = RotatePoint(vertex, -storedRelativeAngle);
+                neighbourData.ModifiedVertices.Add(vertex);


What ensures that multiple membrane shape generators don't write to the same modified vertices at once?

hhyyrylainen · 2026-07-28T07:44:47Z

+
+            var vertexCount = neighbourData.OriginalPointData.VertexCount;
+
+            if (neighbourData.ModifiedVertices != null)


Does this not cause the membrane shape to be different depending on which cells get processed first?

hhyyrylainen · 2026-07-28T07:45:42Z

+
+        if (currentCellData.ModifiedVertices != null)
+        {
+            for (int i = 0; i < currentCellData.OriginalPointData.VertexCount; ++i)


As these both loops run to the same count, I think extracting the count outside the if on line 962 would make sense.

hhyyrylainen · 2026-07-28T07:47:18Z

+                return false;
+            }
+
+            // TODO: throw if negative


Should a negative check be added here?

Patryk26g added 7 commits June 20, 2026 22:20

Experimental multicellular membrane stretch (unstable)

8cdeb63

Working cell rotation

a0c5c5c

Improved middle point calculation and inside point check

2936878

Fix array pool bugs causing hash collisions

6e9edc5

cell growth changes membrane

40a3837

Shape smoothing and Cleaning-up

4d00df7

Smoothing

Second clean-up

583071b

github-project-automation Bot added this to Thrive Planning Jun 28, 2026

github-project-automation Bot moved this to In progress in Thrive Planning Jun 28, 2026

Patryk26g added 8 commits July 1, 2026 21:05

Code clean-up

fa6767b

Clean-up check

25057c1

Import fix

2974e2f

Improvements

a01ba9f

Fixes

04e62bd

Fix CalculateIterationIndices

1f40548

Process current cell and neighbour at the same time. Remove overlaps …

53d9466

…with other neighbours

Documentation

6aa589e

Patryk26g marked this pull request as ready for review July 6, 2026 17:43

Improvements

0cfb7ae

hhyyrylainen reviewed Jul 15, 2026

View reviewed changes

Patryk26g changed the title ~~Experimental membrane stretch~~ Membrane stretch Jul 15, 2026

hhyyrylainen added the review label Jul 15, 2026

hhyyrylainen added this to the Release 1.2.0 milestone Jul 15, 2026

hhyyrylainen reviewed Jul 16, 2026

View reviewed changes

Improve colony key calculation

01c7623

hhyyrylainen reviewed Jul 28, 2026

View reviewed changes

	var cellPosistion = Hex.AxialToCartesian(cell.Position);
	var cellPosition = Hex.AxialToCartesian(cell.Position);

		var positionsArray = cellsPositions.ToArray();
		var rotationsArray = cellsOrientations.ToArray();


		var sourcePoints = dataSource.HexPositions;

		if (dataSource.MulticellularPositions != null \|\| multicellularPositions != null)

		public int? CellOrientation { get; }
		public long? ColonyKey { get; }

		hash = (hash * prime1) ^ BitConverter.SingleToInt32Bits(dataSource.HexPositions[i].X);
		hash = (hash * prime1) ^ BitConverter.SingleToInt32Bits(dataSource.HexPositions[i].Y);

	public static List<long> HandleGenerationRequest(ref MembraneGenerationParameters generationParameters)
	public static void HandleGenerationRequest(ref MembraneGenerationParameters generationParameters, List<long> result)


		tracker.NeighboursData[CellKey(cellPosition)] = singleCellData;

		// Colony not yet complete — return empty

	/// Define from which index of verices2D to which index the points should be moved
	/// Define from which index of vertices2D to which index the points should be moved

	/// <param name="vertices"> The list of vertices </param>
	/// <param name="vertices">The list of vertices</param>


		var vertexCount = neighbourData.OriginalPointData.VertexCount;

		if (neighbourData.ModifiedVertices != null)

Uh oh!

Uh oh!

Conversation

Patryk26g commented Jun 28, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

revolutionary-bot commented Jun 28, 2026

Uh oh!

hhyyrylainen commented Jul 15, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Patryk26g commented Jul 15, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Patryk26g commented Jun 28, 2026 •

edited

Loading